#include "EditorDefaultPackage.h"

#include "Object/NewObject.h"
#include "Containers/Vector.h"
#include "Texture/Texture2D.h"
#include "Material/Shader.h"
#include "Mesh/StaticMesh.h"
#include "Material/Material.h"

#include "Asset/AssetObject.h"
#include "Asset/AssetPath.h"

#include "Render/RenderContext.h"

static REditorDefaultPackage* Instance=nullptr;

void REditorDefaultPackage::Initialize()
{
    Instance=this;

    TSharedObjectPtr<RAssetObject> DefaultAssetObject=WHE::GetEditorDefaultAssetObject();

   
    //add MinimizeIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChromeMinimize.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"MinimizeIcon");
        Icons.Add(U"MinimizeIcon",Texture);
    }
 
    //add MaximizeIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChromeMaximize.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"MaximizeIcon");
        Icons.Add(U"MaximizeIcon",Texture);
    }

    //add RestoreIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChromeRestore.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"RestoreIcon");
        Icons.Add(U"RestoreIcon",Texture);
    }

    //add CloseIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChromeClose.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CloseIcon");
        Icons.Add(U"CloseIcon",Texture);
    }

    //add CodiconInfo
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconInfo.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconInfo");
        Icons.Add(U"CodiconInfo",Texture);
    }

    //add CodiconWarning
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconWarning.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconWarning");
        Icons.Add(U"CodiconWarning",Texture);
    }

    //add CodiconError
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconError.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconError");
        Icons.Add(U"CodiconError",Texture);
    }

    //add CodiconFiles
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconFiles.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconFiles");
        Icons.Add(U"CodiconFiles",Texture);
    }

    //add CodiconFiles_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconFiles_Highlight.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconFiles_Highlight");
        Icons.Add(U"CodiconFiles_Highlight",Texture);
    }

    //add CodiconDebugAlt
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugAlt.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugAlt");
        Icons.Add(U"CodiconDebugAlt",Texture);
    }

    //add CodiconDebugAlt_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugAlt_Highlight.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugAlt_Highlight");
        Icons.Add(U"CodiconDebugAlt_Highlight",Texture);
    }

    //add CodiconSettingsGear
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconSettingsGear.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconSettingsGear");
        Icons.Add(U"CodiconSettingsGear",Texture);
    }

    //add CodiconSettingsGear_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconSettingsGear_Highlight.png.h"
        };
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconSettingsGear_Highlight");
        Icons.Add(U"CodiconSettingsGear_Highlight",Texture);
    }

    //add CodiconLayoutPanel
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLayoutPanel.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLayoutPanel");
        Icons.Add(U"CodiconLayoutPanel",Texture);
    }

    // add CodiconLayoutPanelOff
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLayoutPanelOff.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLayoutPanelOff");
        Icons.Add(U"CodiconLayoutPanelOff",Texture);
    }

    //add CodiconLayoutSidebarLeft
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLayoutSidebarLeft.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLayoutSidebarLeft");
        Icons.Add(U"CodiconLayoutSidebarLeft",Texture);
    }

    //add CodiconLayoutSidebarLeftOff
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLayoutSidebarLeftOff.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLayoutSidebarLeftOff");
        Icons.Add(U"CodiconLayoutSidebarLeftOff",Texture);
    }

    //add CodiconLayoutSidebarRight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLayoutSidebarRight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLayoutSidebarRight");
        Icons.Add(U"CodiconLayoutSidebarRight",Texture);
    }

    //add CodiconLayoutSidebarRightOff
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLayoutSidebarRightOff.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLayoutSidebarRightOff");
        Icons.Add(U"CodiconLayoutSidebarRightOff",Texture);
    }
   
    //add CodiconGoToFile_Blue
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconGoToFile_Blue.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconGoToFile_Blue");
        Icons.Add(U"CodiconGoToFile_Blue",Texture);
    }

    //add CodiconNewFile_Blue
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconNewFile_Blue.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconNewFile_Blue");
        Icons.Add(U"CodiconNewFile_Blue",Texture);
    }

    //add CodiconEllipsis
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconEllipsis.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconEllipsis");
        Icons.Add(U"CodiconEllipsis",Texture);
    }

    //add CodiconClose
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconClose.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconClose");
        Icons.Add(U"CodiconClose",Texture);
    }

    //add CodiconClose_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconClose_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconClose_Highlight");
        Icons.Add(U"CodiconClose_Highlight",Texture);
    }

    //add CodiconChevronDown
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChevronDown.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconChevronDown");
        Icons.Add(U"CodiconChevronDown",Texture);
    }

    //add CodiconChevronRight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChevronRight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconChevronRight");
        Icons.Add(U"CodiconChevronRight",Texture);
    }

    //add CodiconChevronUp
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChevronUp.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconChevronUp");
        Icons.Add(U"CodiconChevronUp",Texture);
    }

    //add CodiconChevronLeft
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconChevronLeft.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconChevronLeft");
        Icons.Add(U"CodiconChevronLeft",Texture);
    }

    //add CodiconCircleFilled
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconCircleFilled.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconCircleFilled");
        Icons.Add(U"CodiconCircleFilled",Texture);
    }

    //add CodiconCircleFilled_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconCircleFilled_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconCircleFilled_Highlight");
        Icons.Add(U"CodiconCircleFilled_Highlight",Texture);
    }

    //add CodiconNewFile
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconNewFile.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconNewFile");
        Icons.Add(U"CodiconNewFile",Texture);
    }

    //add CodiconNewFolder
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconNewFolder.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconNewFolder");
        Icons.Add(U"CodiconNewFolder",Texture);
    }

    //add CodiconRefresh
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconRefresh.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconRefresh");
        Icons.Add(U"CodiconRefresh",Texture);
    }

    //add CodiconCollapseAll
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconCollapseAll.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconCollapseAll");
        Icons.Add(U"CodiconCollapseAll",Texture);
    }

    //add CodiconOutput
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconOutput.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconOutput");
        Icons.Add(U"CodiconOutput",Texture);
    }

    //add CodiconOutput_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconOutput_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconOutput_Highlight");
        Icons.Add(U"CodiconOutput_Highlight",Texture);
    }

    //add CodiconClearAll
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconClearAll.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconClearAll");
        Icons.Add(U"CodiconClearAll",Texture);
    }

    //add CodiconDebugConsole
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugConsole.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugConsole");
        Icons.Add(U"CodiconDebugConsole",Texture);
    }

    //add CodiconDebugConsole_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugConsole_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugConsole_Highlight");
        Icons.Add(U"CodiconDebugConsole_Highlight",Texture);
    }

    //add CodiconDebugStart
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugStart.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugStart");
        Icons.Add(U"CodiconDebugStart",Texture);
    }

    //add CodiconGripper
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconGripper.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconGripper");
        Icons.Add(U"CodiconGripper",Texture);
    }

    //add CodiconDebugStop
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugStop.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugStop");
        Icons.Add(U"CodiconDebugStop",Texture);
    }

    //add CodiconDebugPause
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugPause.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugPause");
        Icons.Add(U"CodiconDebugPause",Texture);
    }

    //add CodiconDebugStepOver
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugStepOver.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugStepOver");
        Icons.Add(U"CodiconDebugStepOver",Texture);
    }

    //add CodiconDebugStepOut
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugStepOut.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugStepOut");
        Icons.Add(U"CodiconDebugStepOut",Texture);
    }

    //add CodiconDebugStepInto
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugStepInto.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugStepInto");
        Icons.Add(U"CodiconDebugStepInto",Texture);
    }

    //add CodiconDebugStepBack
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugStepBack.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugStepBack");
        Icons.Add(U"CodiconDebugStepBack",Texture);
    }

    //add CodiconDebugContinue
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugContinue.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugContinue");
        Icons.Add(U"CodiconDebugContinue",Texture);
    }

    //add CodiconDebugRestart
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconDebugRestart.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconDebugRestart");
        Icons.Add(U"CodiconDebugRestart",Texture);
    }

  //add CodiconSplitHorizontal
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconSplitHorizontal.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconSplitHorizontal");
        Icons.Add(U"CodiconSplitHorizontal",Texture);
    }

    //add CodiconSplitVertical
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconSplitVertical.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconSplitVertical");
        Icons.Add(U"CodiconSplitVertical",Texture);
    }

    //add CodiconUnlock
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconUnlock.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconUnlock");
        Icons.Add(U"CodiconUnlock",Texture);
    }

    //add CodiconLock
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconLock.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconLock");
        Icons.Add(U"CodiconLock",Texture);
    }

    //CodiconBell
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconBell.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconBell");
        Icons.Add(U"CodiconBell",Texture);
    }

    //CodiconBellDot
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconBellDot.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconBellDot");
        Icons.Add(U"CodiconBellDot",Texture);
    }

    //CodiconBellSlash
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconBellSlash.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconBellSlash");
        Icons.Add(U"CodiconBellSlash",Texture);
    }

    //CodiconBellSlashDot
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconBellSlashDot.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconBellSlashDot");
        Icons.Add(U"CodiconBellSlashDot",Texture);
    }

    //CodiconArrowDown
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconArrowDown.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconArrowDown");
        Icons.Add(U"CodiconArrowDown",Texture);
    }

    //CodiconArrowUp
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconArrowUp.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconArrowUp");
        Icons.Add(U"CodiconArrowUp",Texture);
    }

    //CodiconListSelection
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconListSelection.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconListSelection");
        Icons.Add(U"CodiconListSelection",Texture);
    }

    //CodiconReplace
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconReplace.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconReplace");
        Icons.Add(U"CodiconReplace",Texture);
    }

    //CodiconReplaceAll
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconReplaceAll.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconReplaceAll");
        Icons.Add(U"CodiconReplaceAll",Texture);
    }

    //CodiconArrowDown_Dark
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconArrowDown_Dark.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconArrowDown_Dark");
        Icons.Add(U"CodiconArrowDown_Dark",Texture);
    }

    //CodiconArrowUp_Dark
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/CodiconArrowUp_Dark.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"CodiconArrowUp_Dark");
        Icons.Add(U"CodiconArrowUp_Dark",Texture);
    }

    //PlayScene
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/PlayScene.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"PlayScene");
        Icons.Add(U"PlayScene",Texture);
    }

    //StopScene
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/StopPlayScene.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"StopPlayScene");
        Icons.Add(U"StopPlayScene",Texture);
    }

    //PauseScene
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/PausePlayScene.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"PausePlayScene");
        Icons.Add(U"PausePlayScene",Texture);
    }
    //add MaterialIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/MaterialIcon.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"MaterialIcon");
        Icons.Add(U"MaterialIcon",Texture);
    }

    //add MeshIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/MeshIcon.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"MeshIcon");
        Icons.Add(U"MeshIcon",Texture);
    }

    //add ScriptIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/ScriptIcon.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"ScriptIcon");
        Icons.Add(U"ScriptIcon",Texture);
    }


    //add SoundIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/SoundIcon.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"SoundIcon");
        Icons.Add(U"SoundIcon",Texture);
    }
    
    //add SceneIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/SceneIcon.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"SceneIcon");
        Icons.Add(U"SceneIcon",Texture);
    }
 //add Property
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/Property.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Property");
        Icons.Add(U"Property",Texture);
    }

    //add Property_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/Property_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Property_Highlight");
        Icons.Add(U"Property_Highlight",Texture);
    }
    
    //add TextureIcon
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Microsoft/TextureIcon.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"TextureIcon");
        Icons.Add(U"TextureIcon",Texture);
    }
    //tabler icons:

    //add PlayerPlay
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/tabler/PlayerPlay.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"PlayerPlay");
        Icons.Add(U"PlayerPlay",Texture);
    }

    //add PlayerPause
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/tabler/PlayerPause.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"PlayerPause");
        Icons.Add(U"PlayerPause",Texture);
    }
//BoxiconsSolid icons:

    //add VolumeFull
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/BoxiconsSolid/VolumeFull.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"VolumeFull");
        Icons.Add(U"VolumeFull",Texture);
    }

    //add VolumeMute
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/BoxiconsSolid/VolumeMute.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"VolumeMute");
        Icons.Add(U"VolumeMute",Texture);
    }

//phosphor:

    //add SceneNodeTree
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Phosphor/SceneNodeTree.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"SceneNodeTree");
        Icons.Add(U"SceneNodeTree",Texture);
    }

    //add SceneNodeTree_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Phosphor/SceneNodeTree_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"SceneNodeTree_Highlight");
        Icons.Add(U"SceneNodeTree_Highlight",Texture);
    }

    //add Compile
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Phosphor/Compile.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Compile");
        Icons.Add(U"Compile",Texture);
    }

//Googles icon:

    //add MaterialSymbolsPreviewSharp
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Google/MaterialSymbolsPreviewSharp.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"MaterialSymbolsPreviewSharp");
        Icons.Add(U"MaterialSymbolsPreviewSharp",Texture);
    }

    //add MaterialSymbolsPreviewSharp_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Google/MaterialSymbolsPreviewSharp_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"MaterialSymbolsPreviewSharp_Highlight");
        Icons.Add(U"MaterialSymbolsPreviewSharp_Highlight",Texture);
    }


    //add Checked
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Google/Checked.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Checked");
        Icons.Add(U"Checked",Texture);
    }

    //add Unchecked
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Google/Unchecked.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Unchecked");
        Icons.Add(U"Unchecked",Texture);
    }

    //add Checked_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Google/Checked_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Checked_Highlight");
        Icons.Add(U"Checked_Highlight",Texture);
    }

    //add Unchecked_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/Google/Unchecked_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"Unchecked_Highlight");
        Icons.Add(U"Unchecked_Highlight",Texture);
    }

//myself designed icon

    //add AddNode
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/AddNode.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"AddNode");
        Icons.Add(U"AddNode",Texture);
    }

    //add AddNode_Highlight
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/AddNode_Highlight.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"AddNode_Highlight");
        Icons.Add(U"AddNode_Highlight",Texture);
    }

    //NewAssetFile
    {
        TVector< uint8_t> IconFileData=
        {
            #include "Icons/NewAssetFile.png.h"
        }; 
        auto Texture= RTexture2D::CreateFromPNGFileData(std::move(IconFileData),DefaultAssetObject.Get());
        Texture->SetNodeName(U"NewAssetFile");
        Icons.Add(U"NewAssetFile",Texture);
    }


}

void REditorDefaultPackage::Deinitialize()
{
    Instance=nullptr;
}

REditorDefaultPackage *REditorDefaultPackage::Get()
{
    assert(Instance!=nullptr);
    return Instance;
}


TSharedObjectPtr<RTexture2D> REditorDefaultPackage::GetMinimizeIcon()
{
    return GetIcon(U"MinimizeIcon");
}

TSharedObjectPtr<RTexture2D> REditorDefaultPackage::GetMaximizeIcon()
{
    return GetIcon(U"MaximizeIcon");
}

TSharedObjectPtr<RTexture2D> REditorDefaultPackage::GetRestoreIcon()
{
    return GetIcon(U"RestoreIcon");
}

TSharedObjectPtr<RTexture2D> REditorDefaultPackage::GetCloseIcon()
{
    return GetIcon(U"CloseIcon");
}

TSharedObjectPtr<RTexture2D> REditorDefaultPackage::GetIcon(const CString &InIconName)
{
    auto Icon=Icons.Find(InIconName);
    if(Icon)
    {
        return *Icon;
    }
    else
    {
        return nullptr;
    }
}

static TWeakObjectPtr<RAssetObject> WeakDefaultAssetObject;

TSharedObjectPtr<RAssetObject> WHE::GetEditorDefaultAssetObject()
{
    if(!WeakDefaultAssetObject)
    {
        //create default asset object
        TSharedObjectPtr<RAssetObject> DefaultAssetObject=NewObject<RAssetObject>((RObject*)WH::GetRootObject());
        DefaultAssetObject->SetNodeName(U"EditorDefaultAssetObject");
        DefaultAssetObject->SetAssetPath(
            SAssetPath(RObject::StaticClass()
                ,CString(U"EngineEditor2")
                ,CString(U"./")
                ,CString(U"DefaultAsset"))
        );
        DefaultAssetObject->bAlwaysInMemory=true;
        WeakDefaultAssetObject=DefaultAssetObject;

        return DefaultAssetObject;
    }
    else
    {
        return WeakDefaultAssetObject;
    }
}
